package com.openx.cloud.server.autoconfigure.utils;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.openx.boot.core.model.ApiResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.*;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.io.File;
import java.util.Map;

/**
 * 自定义RestTemplate请求工具类
 *
 * @author: liuyadu
 * @date: 2018/12/11 15:51
 * @description:
 */
@Slf4j
public class RestTemplateUtil {
    private static final ObjectMapper objectMapper = new ObjectMapper();
    private RestTemplate restTemplate;
    private LoadBalancerClient loadBalancerClient;

    public RestTemplateUtil(RestTemplate restTemplate, LoadBalancerClient loadBalancerClient) {
        this.restTemplate = restTemplate;
        this.loadBalancerClient = loadBalancerClient;
    }

    /**
     * post 请求
     *
     * @param url     请求地址
     * @param headers 请求头
     * @param params  参数
     * @param tClass  返回类型
     * @param <T>
     * @return
     */
    public <T> T post(String url, Map<String, String> headers, Map<String, String> params, Class<T> tClass) {
        return restTemplate.postForObject(url, getHttpEntity(headers, params), tClass);
    }

    /**
     * post json请求
     *
     * @param url     请求地址
     * @param headers 请求头
     * @param body    请求内容
     * @param tClass  返回类型
     * @param <T>
     * @return
     */
    public <T> T postJson(String url, Map<String, String> headers, Object body, Class<T> tClass) {
        MultiValueMap<String, String> headersMap = new LinkedMultiValueMap<>();
        if (headers != null) {
            headersMap.setAll(headers);
        }
        headersMap.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_UTF8_VALUE);
        return restTemplate.postForObject(url, new HttpEntity<>(JSONObject.toJSONString(body), headersMap), tClass);
    }

    /**
     * get请求
     *
     * @param url    请求地址
     * @param tClass 返回类型
     * @param <T>
     * @return
     */
    public <T> T get(String url, Class<T> tClass) {
        return restTemplate.getForObject(url, tClass);
    }

    /**
     * post请求
     *
     * @param serviceId 服务id > spring.application.name
     * @param path      请求地址
     * @param headers   请求头
     * @param params    参数
     * @param tClass    返回类型
     * @param <T>
     * @return
     */
    public <T> T post(String serviceId, String path, Map<String, String> headers, Map<String, String> params, Class<T> tClass) {
        String url = String.format("%s%s", getServiceInstance(serviceId), path);
        return post(url, headers, params, tClass);
    }

    /**
     * get请求
     *
     * @param serviceId 服务id > spring.application.name
     * @param path      请求地址
     * @param tClass    返回类型
     * @param <T>
     * @return
     */
    public <T> T get(String serviceId, String path, Class<T> tClass) {
        String url = String.format("%s%s", getServiceInstance(serviceId), path);
        return get(url, tClass);
    }


    /**
     * get请求返回 ApiResponse中的泛型
     *
     * @param url    请求地址
     * @param tClass 返回类型
     * @param <T>
     * @return
     */
    public <T> ApiResponse<T> getForApiResponse(String url, Class<T> tClass) {
        return restTemplate.exchange(url, HttpMethod.GET, getHttpEntity(null, null), getReference(tClass)).getBody();
    }

    /**
     * get请求返回 ApiResponse中的泛型
     *
     * @param serviceId 服务id > spring.application.name
     * @param path      请求地址
     * @param tClass    返回类型
     * @param <T>
     * @return
     */
    public <T> ApiResponse<T> getForApiResponse(String serviceId, String path, Class<T> tClass) {
        String url = String.format("%s%s", getServiceInstance(serviceId), path);
        return getForApiResponse(url, tClass);
    }

    /**
     * post 请求返回 ApiResponse中的泛型
     *
     * @param url     请求地址
     * @param headers 请求头
     * @param params  参数
     * @param tClass  返回类型
     * @param <T>
     * @return
     */
    public <T> ApiResponse<T> postForApiResponse(String url, Map<String, String> headers, Map<String, String> params, Class<T> tClass) {
        return restTemplate.exchange(url, HttpMethod.POST, getHttpEntity(headers, params), getReference(tClass)).getBody();
    }

    /**
     * post 请求返回 ApiResponse中的泛型
     *
     * @param serviceId 服务id > spring.application.name
     * @param path      请求地址
     * @param headers   请求头
     * @param params    参数
     * @param tClass    返回类型
     * @param <T>
     * @return
     */
    public <T> ApiResponse<T> postForApiResponse(String serviceId, String path, Map<String, String> headers, Map<String, String> params, Class<T> tClass) {
        String url = String.format("%s%s", getServiceInstance(serviceId), path);
        return postForApiResponse(url, headers, params, tClass);
    }

    /**
     * post json 请求返回 ApiResponse中的泛型
     *
     * @param url     请求地址
     * @param headers 请求头
     * @param body    请求内容
     * @param tClass  返回类型
     * @param <T>
     * @return
     */
    public <T> ApiResponse<T> postJsonForApiResponse(String url, Map<String, String> headers, Object body, Class<T> tClass) {
        MultiValueMap<String, String> headersMap = new LinkedMultiValueMap<>();
        if (headers != null) {
            headersMap.setAll(headers);
        }
        headersMap.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        return restTemplate.exchange(url, HttpMethod.POST, new HttpEntity(JSONObject.toJSONString(body)), getReference(tClass)).getBody();
    }

    /**
     * post json 请求返回 ApiResponse中的泛型
     *
     * @param serviceId 服务id > spring.application.name
     * @param path      请求地址
     * @param headers   请求头
     * @param body      请求内容
     * @param tClass    返回类型
     * @param <T>
     * @return
     */
    public <T> ApiResponse<T> postJsonForApiResponse(String serviceId, String path, Map<String, String> headers, Object body, Class<T> tClass) {
        String url = String.format("%s%s", getServiceInstance(serviceId), path);
        return postJsonForApiResponse(url, headers, body, tClass);
    }

    /**
     * 文件上传
     *
     * @param file      文件
     * @param uploadUrl 上传地址
     * @param tClass    返回类型
     * @return
     */
    public <T> T upload(File file, String uploadUrl, Class<T> tClass) {
        if (file != null && !file.exists()) {
            return null;
        }
        //将文件传入文件管理系统
        FileSystemResource resource = new FileSystemResource(file);
        MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
        param.add("file", resource);
        ResponseEntity<T> responseEntity = restTemplate.postForEntity(uploadUrl, param, tClass);
        //删除本地文件
        file.delete();
        return responseEntity.getBody();
    }

    /**
     * 获取服务实例
     *
     * @param serviceId
     * @return
     */
    public String getServiceInstance(String serviceId) {
        ServiceInstance serviceInstance = loadBalancerClient.choose(serviceId);
        // 查询服务实例
        if (serviceInstance == null) {
            throw new RuntimeException(String.format("未找到服务实例:%s", serviceId));
        }
        return serviceInstance.getUri().toString();
    }

    /**
     * 封装请求参数
     *
     * @param headers
     * @param params
     * @return
     */
    public HttpEntity getHttpEntity(Map<String, String> headers, Map<String, String> params) {
        //header信息，包括了http basic认证信息
        MultiValueMap<String, String> headersMap = new LinkedMultiValueMap<>();
        if (headers != null) {
            headersMap.setAll(headers);
        }
        //body请求体部分
        MultiValueMap<String, String> bodyMap = new LinkedMultiValueMap<>();
        if (params != null) {
            bodyMap.setAll(params);
        }
        //merge成为一个HttpEntity
        return new HttpEntity<>(bodyMap, headersMap);
    }

    /**
     * 获取泛型
     *
     * @param clazz
     * @param <T>
     * @return
     */
    private <T> ParameterizedTypeReference<ApiResponse<T>> getReference(Class<T> clazz) {
        //objectMapper已经缓存Type，不需要额外缓存
        JavaType javaType = objectMapper.getTypeFactory().constructParametrizedType(ApiResponse.class, ApiResponse.class, clazz);
        return ParameterizedTypeReference.forType(javaType);
    }


    public RestTemplate getRestTemplate() {
        return restTemplate;
    }

    public void setRestTemplate(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
}
